home *** CD-ROM | disk | FTP | other *** search
/ Mac Expert 1995 Winter / Mac Expert - Winter 95.iso / Les fichiers / Utilitaires divers / Divers / C64-Emulator 0.4 ƒ / SOURCE / Instructions68K.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-02  |  21.3 KB  |  1,546 lines  |  [TEXT/KAHL]
  1. /*
  2.     Commodore 64 Emulator v0.4      Earle F. Philhower III 
  3.     Copyright (C) 1993-4            (st916w9r@dunx1.ocs.drexel.edu)
  4.  
  5.     High Speed 68K CPU by George T. Talbot
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #ifndef __MWERKS__
  23.  
  24. #include "Processor.h"
  25. #include "Registers68K.h"
  26. #include "Flags68K.h"
  27. #include "Instructions68K.h"
  28. #include "Stack68K.h"
  29. #include "Modes68K.h"
  30. #include "Memory68K.h"
  31.  
  32.  
  33. /*    Rather than using multiplication and division to do the BCD math, it's implemented
  34.  *    with lookup tables--faster and easier to code in 68K assembly.
  35.  *  These are defined in Instructions.c
  36.  */
  37. extern unsigned char    bcd2dec[];
  38. extern unsigned char    dec2bcd[];
  39.  
  40. /*    To try to improve the hit-rate on the cached processors (68030, 68040), I tried
  41.  *    to make the routines shorter by having them come here to set the ZER and NEG
  42.  *    flags.  This incurs a 2 instruction penalty every time it's used, but hopefully
  43.  *    it'll speed up the other aspects.  (We'll have to test it).  This shaves about
  44.  *    1K off the CPU emulation code size.
  45.  */
  46. void doFlagsNZ()
  47.     {
  48.     asm    {
  49.         ANDI.B        #0xFF-(ZER|NEG),rFLAGS
  50.         TST.B        D0
  51.         BEQ            @1
  52.         NegSet(D0)
  53.         RTS
  54. @1        BSET        #bZER,rFLAGS
  55.         }
  56.     }
  57.  
  58. /*    Here follow the instructions.  They are pretty much translated from their C
  59.  *    counterparts.  The same macro names are used, for consistency.
  60.  */
  61. void i00f() 
  62.     {
  63.     asm    {
  64.         PushWord(rPC)
  65.         Push(rFLAGS)
  66.         OR.B    #BKC,rFLAGS
  67.         WordAt(IrqTo, rPC)
  68.         }
  69.     }
  70.  
  71. void i01f() /*{ ORA(IndirectXAddr); pc++; }*/
  72.     {
  73.     asm    {
  74.         ORA(IndirectXAddr)
  75.         PC(#1)
  76.         }
  77.     }
  78.  
  79. void i05f() /*{ ORA(ZeroPageAddr); pc++; }*/
  80.     {
  81.     asm    {
  82.         ORA(ZeroPageAddr)
  83.         PC(#1)
  84.         }
  85.     }
  86.  
  87. void i06f() /*{ ASL(ZeroPageAddr); pc++; }*/
  88.     {
  89.     asm    {
  90.         ASL(ZeroPageAddr)
  91.         PC(#1)
  92.         }
  93.     }
  94.     
  95. void i08f()
  96.     {
  97.     asm    {
  98.         Push(rFLAGS)
  99.         }
  100.     }
  101.  
  102. void i09f() /*{ a |= ImmediateByte(); FlagsNZ(a); pc++; }*/
  103.     {
  104.     asm    {
  105.         ImmediateByte(D1)
  106.         OR.B    D1,rA
  107.         FlagsNZ(rA)
  108.         PC(#1)
  109.         }
  110.     }
  111.  
  112. void i0af() /*{
  113.     if (a&128) flags |= CAR;
  114.     else flags &= ~CAR;
  115.     a=a<<1;
  116.     FlagsNZ(a); }*/
  117.     {
  118.     asm    {
  119.         ANDI.B    #0xFF-CAR,rFLAGS
  120.         BTST    #7,rA
  121.         BEQ        @3
  122.         ORI.B    #CAR,rFLAGS
  123. @3        LSL.B    #1,rA
  124.         FlagsNZ(rA)
  125.         }
  126.     }
  127.  
  128. void i0df() /*{ ORA(AbsoluteAddr); pc+=2; }*/
  129.     {
  130.     asm    {
  131.         ORA(AbsoluteAddr)
  132.         PC(#2)
  133.         }
  134.     }
  135.  
  136. void i0ef() /*{ ASL(AbsoluteAddr); pc+=2; }*/
  137.     {
  138.     asm    {
  139.         ASL(AbsoluteAddr)
  140.         PC(#2)
  141.         }
  142.     }
  143.  
  144. void i10f() /*{ BCL(NEG); }*/
  145.     {
  146.     asm    {
  147.         BCL(#bNEG)
  148.         }
  149.     }
  150.  
  151. void i11f() /*{ ORA(IndirectYAddr); pc++; }*/
  152.     {
  153.     asm    {
  154.         ORA(IndirectYAddr)
  155.         PC(#1)
  156.         }
  157.     }
  158.  
  159. void i15f() /*{ ORA(ZeroPageXAddr); pc++; }*/
  160.     {
  161.     asm    {
  162.         ORA(ZeroPageXAddr)
  163.         PC(#1)
  164.         }
  165.     }
  166.  
  167. void i16f() /*{ ASL(ZeroPageXAddr); pc++; }*/
  168.     {
  169.     asm    {
  170.         ASL(ZeroPageXAddr)
  171.         PC(#1)
  172.         }
  173.     }
  174.  
  175. void i18f()    /*{ CLR(CAR); }*/
  176.     {
  177.     asm    {
  178.         CLR(#bCAR)
  179.         }
  180.     }
  181.  
  182. void i19f() /*{ ORA(AbsoluteYAddr); pc+=2; }*/
  183.     {
  184.     asm    {
  185.         ORA(AbsoluteYAddr)
  186.         PC(#2)
  187.         }
  188.     }
  189.  
  190. void i1df() /*{ ORA(AbsoluteXAddr); pc+=2; }*/
  191.     {
  192.     asm    {
  193.         ORA(AbsoluteXAddr)
  194.         PC(#2)
  195.         }
  196.     }
  197.  
  198. void i1ef() /*{ ASL(AbsoluteXAddr); pc+=2; }*/
  199.     {
  200.     asm    {
  201.         ASL(AbsoluteXAddr)
  202.         PC(#2)
  203.         }
  204.     }
  205.  
  206. void    i20f()
  207.     {
  208.     asm    {
  209.         MOVE.W    rPC,D1
  210.         ADDQ.W    #1,D1
  211.         PushWord(D1)
  212.         WordAt(rPC,rPC)
  213.         }
  214.     }
  215.  
  216. void i21f() /*{ AND(IndirectXAddr); pc++; }*/
  217.     {
  218.     asm    {
  219.         AND(IndirectXAddr)
  220.         PC(#1)
  221.         }
  222.     }
  223.  
  224. void i24f() /*{ BIT(ZeroPageAddr); pc++; }*/
  225.     {
  226.     asm    {
  227.         BIT(ZeroPageAddr)
  228.         PC(#1)
  229.         }
  230.     }
  231.  
  232. void i25f() /*{ AND(ZeroPageAddr); pc++; }*/
  233.     {
  234.     asm    {
  235.         AND(ZeroPageAddr)
  236.         PC(#1)
  237.         }
  238.     }
  239.  
  240. void i26f() /*{ ROL(ZeroPageAddr); pc++; }*/
  241.     {
  242.     asm    {
  243.         ROL(ZeroPageAddr)
  244.         ADDQ.W        #1,rPC
  245.         }
  246.     }
  247.  
  248. void    i28f()
  249.     {
  250.     asm    {
  251.         Pop(rFLAGS)
  252.         }
  253.     }
  254.  
  255. void i29f() /*{ a &= ImmediateByte(); FlagsNZ(a); pc++; }*/
  256.     {
  257.     asm    {
  258.         ImmediateByte(D0)
  259.         AND.B        D0,rA
  260.         FlagsNZ(rA)
  261.         ADDQ.W        #1,rPC
  262.         }
  263.     }
  264.  
  265. void i2af() /*{
  266.     if (flags&CAR) {
  267.         if ((a&128)==0) flags &=~CAR;
  268.         a=(a<<1)|1; }
  269.     else {
  270.         if(a&128)flags|=CAR;
  271.         a=a<<1; }
  272.     FlagsNZ(a);
  273. }*/
  274.     {
  275.     asm    {
  276.         BTST    #bCAR,rFLAGS
  277.         BEQ        @x1
  278.         BTST    #7,rA
  279.         BNE        @x2
  280.         BCLR    #bCAR,rFLAGS
  281. @x2        LSL.B    #1,rA
  282.         OR.B    #1,rA
  283.         BRA        @x3
  284. @x1        BTST    #7,rA
  285.         BEQ        @x4
  286.         BSET    #bCAR,rFLAGS
  287. @x4        LSL.B    #1,rA
  288. @x3        FlagsNZ(rA)
  289.         }
  290.     }
  291.  
  292. void i2cf() /*{ BIT(AbsoluteAddr); pc+=2; }*/
  293.     {
  294.     asm    {
  295.         BIT(AbsoluteAddr)
  296.         PC(#2)
  297.         }
  298.     }
  299.  
  300. void i2df() /*{ AND(AbsoluteAddr); pc+=2; }*/
  301.     {
  302.     asm    {
  303.         AND(AbsoluteAddr)
  304.         PC(#2)
  305.         }
  306.     }
  307.  
  308. void i2ef() /*{ ROL(AbsoluteAddr); pc+=2; }*/
  309.     {
  310.     asm    {
  311.         ROL(AbsoluteAddr)
  312.         PC(#2)
  313.         }
  314.     }
  315.  
  316. void i30f() /*{ BST(NEG); }*/
  317.     {
  318.     asm    {
  319.         BST(#bNEG)
  320.         }
  321.     }
  322.  
  323. void i31f() /*{ AND(IndirectYAddr); pc++; }*/
  324.     {
  325.     asm    {
  326.         AND(IndirectYAddr)
  327.         PC(#1)
  328.         }
  329.     }
  330.  
  331. void i35f() /*{ AND(ZeroPageXAddr); pc++; }*/
  332.     {
  333.     asm    {
  334.         AND(ZeroPageXAddr)
  335.         PC(#1)
  336.         }
  337.     }
  338.     
  339. void i36f() /*{ ROL(ZeroPageXAddr); pc++; }*/
  340.     {
  341.     asm    {
  342.         ROL(ZeroPageXAddr)
  343.         PC(#1)
  344.         }
  345.     }
  346.  
  347. void i38f() /*{ SET(CAR); }*/
  348.     {
  349.     asm    {
  350.         SET(#bCAR)
  351.         }
  352.     }
  353.  
  354. void i39f() /*{ AND(AbsoluteYAddr); pc+=2; }*/
  355.     {
  356.     asm    {
  357.         AND(AbsoluteYAddr)
  358.         PC(#2)
  359.         }
  360.     }
  361.  
  362. void i3df() /*{ AND(AbsoluteXAddr); pc+=2; }*/
  363.     {
  364.     asm    {
  365.         AND(AbsoluteXAddr)
  366.         PC(#2)
  367.         }
  368.     }
  369.  
  370. void i3ef() /*{ ROL(AbsoluteXAddr); pc+=2; }*/
  371.     {
  372.     asm    {
  373.         ROL(AbsoluteXAddr)
  374.         PC(#2)
  375.         }
  376.     }
  377.  
  378. void i40f() /*{ flags=Pop(); PopWord(pc); }*/
  379.     {
  380.     asm    {
  381.         Pop(rFLAGS)
  382.         PopWord(rPC)
  383.         }
  384.     }
  385.  
  386. void i41f() /*{ EOR(IndirectXAddr); pc++; }*/
  387.     {
  388.     asm    {
  389.         EOR(IndirectXAddr)
  390.         PC(#1)
  391.         }
  392.     }
  393.  
  394. void i45f() /*{ EOR(ZeroPageAddr); pc++; }*/
  395.     {
  396.     asm    {
  397.         EOR(ZeroPageAddr)
  398.         PC(#1);
  399.         }
  400.     }
  401.  
  402. void i46f() /*{ LSR(ZeroPageAddr); pc++; }*/
  403.     {
  404.     asm    {
  405.         LSR(ZeroPageAddr)
  406.         PC(#1)
  407.         }
  408.     }
  409.  
  410. void    i48f()
  411.     {
  412.     asm    {
  413.         Push(rA)
  414.         }
  415.     }
  416.  
  417. void i49f() /*{ a ^= ImmediateByte(); FlagsNZ(a); pc++; }*/
  418.     {
  419.     asm    {
  420.         ImmediateByte(D1)
  421.         EOR.B    D1,rA
  422.         FlagsNZ(rA)
  423.         PC(#1)
  424.         }
  425.     }
  426.  
  427. void i4af() /*{ 
  428.     flags &=~(CAR+NEG+ZER);
  429.     if (a&1) flags |=CAR;
  430.     if (a=a>>1); else flags |=ZER;
  431. }*/
  432.     {
  433.     asm    {
  434.         AND.B    #0xFF-(CAR|NEG|ZER),rFLAGS
  435.         BTST    #0,rA
  436.         BEQ        @1
  437.         BSET    #bCAR,rFLAGS
  438. @1        LSR.B    #1,rA
  439.         BNE        @2
  440.         BSET    #bZER,rFLAGS
  441. @2
  442.         }
  443.     }
  444.  
  445. void i4cf() /*{ pc=WordAt(pc); }*/
  446.     {
  447.     asm    {
  448.         WordAt(rPC,rPC)
  449.         }
  450.     }
  451.  
  452. void i4df() /*{ EOR(AbsoluteAddr); pc+=2; }*/
  453.     {
  454.     asm    {
  455.         EOR(AbsoluteAddr)
  456.         PC(#2)
  457.         }
  458.     }
  459.  
  460. void i4ef() /*{ LSR(AbsoluteAddr); pc+=2; }*/
  461.     {
  462.     asm    {
  463.         LSR(AbsoluteAddr)
  464.         PC(#2)
  465.         }
  466.     }
  467.  
  468. void i50f() /*{ BCL(OVF); }*/
  469.     {
  470.     asm    {
  471.         BCL(#bOVF)
  472.         }
  473.     }
  474.  
  475. void i51f() /*{ EOR(IndirectYAddr); pc++; }*/
  476.     {
  477.     asm    {
  478.         EOR(IndirectYAddr)
  479.         PC(#1)
  480.         }
  481.     }
  482.  
  483. void i55f() /*{ EOR(ZeroPageXAddr); pc++; }*/
  484.     {
  485.     asm    {
  486.         EOR(ZeroPageXAddr)
  487.         PC(#1)
  488.         }
  489.     }
  490.  
  491. void i56f() /*{ LSR(ZeroPageXAddr); pc++; }*/
  492.     {
  493.     asm    {
  494.         LSR(ZeroPageXAddr)
  495.         PC(#1)
  496.         }
  497.     }
  498.  
  499. void i58f() /*{ CLR(INT); }*/
  500.     {
  501.     asm    {
  502.         CLR(#bINT)
  503.         }
  504.     }
  505.  
  506. void i59f() /*{ EOR(AbsoluteYAddr); pc+=2; }*/
  507.     {
  508.     asm    {
  509.         EOR(AbsoluteYAddr)
  510.         PC(#2)
  511.         }
  512.     }
  513.  
  514. void i5df() /*{ EOR(AbsoluteXAddr); pc+=2; }*/
  515.     {
  516.     asm    {
  517.         EOR(AbsoluteXAddr)
  518.         PC(#2)
  519.         }
  520.     }
  521.  
  522. void i5ef() /*{ LSR(AbsoluteXAddr); pc+=2; }*/
  523.     {
  524.     asm    {
  525.         LSR(AbsoluteXAddr)
  526.         PC(#2)
  527.         }
  528.     }
  529.  
  530. void i60f() /*{ PopWord(pc); pc++; }*/
  531.     {
  532.     asm    {
  533.         PopWord(rPC)
  534.         PC(#1)
  535.         }
  536.     }
  537.  
  538. void i61f() /*{ ADC(IndirectXAddr); pc++; }*/
  539.     {
  540.     asm    {
  541.         ADC(IndirectXAddr)
  542.         PC(#1)
  543.         }
  544.     }
  545.  
  546. void i65f() /*{ ADC(ZeroPageAddr); pc++; }*/
  547.     {
  548.     asm    {
  549.         ADC(ZeroPageAddr)
  550.         PC(#1)
  551.         }
  552.     }
  553.  
  554. void i66f() /*{ ROR(ZeroPageAddr); pc++; }*/
  555.     {
  556.     asm    {
  557.         ROR(ZeroPageAddr)
  558.         PC(#1)
  559.         }
  560.     }
  561.  
  562. void    i68f()
  563.     {
  564.     asm {
  565.         Pop(rA)
  566.         FlagsNZ(rA)
  567.         }
  568.     }
  569.  
  570. void i69f() /*{
  571.     register word data;
  572.     data=ImmediateByte();
  573.     if (flags&DEC) {
  574.         data = BCD2DEC(data)+BCD2DEC(a)+((flags&CAR)?1:0);
  575.         flags &= ~(CAR+OVF+NEG+ZER);
  576.         if (data>99) {
  577.             flags|=CAR+OVF;
  578.             data -=100; }
  579.         if (data==0) flags |= ZER;
  580.         else flags |= data&128;
  581.         DEC2BCD(data,a); }
  582.     else {
  583.         data += a+((flags&CAR)?1:0);
  584.         flags &= ~(CAR+OVF+NEG+ZER);
  585.         if (data>255) {
  586.             flags|=OVF+CAR;
  587.             data &=255; }
  588.         if (data==0) flags |= ZER;
  589.         else flags |= data&128;
  590.         a=data; }
  591.     pc++;
  592. }*/
  593.     {
  594.     asm    {
  595.         ImmediateByte(D1)
  596.         BTST    #bDEC,rFLAGS
  597.         BNE        @3
  598.         ANDI.W    #0x00FF,rA
  599.         ADD.W    D1,rA
  600.         BTST    #bCAR,rFLAGS
  601.         BEQ        @7
  602.         ADDQ.W    #1,rA
  603. @7        ANDI.B    #0xFF-(CAR|OVF|NEG|ZER),rFLAGS
  604.         CMPI.W    #0xFF,rA
  605.         BLS        @8
  606.         OR.B    #(OVF|CAR),rFLAGS
  607. @8        FlagsNZ(rA)
  608.         BRA        @6
  609.  
  610. @3        BCD2DEC(D1)
  611.         BCD2DEC(rA)
  612.         ADD.W    D1,rA
  613.         BTST    #bCAR,rFLAGS
  614.         BEQ        @4
  615.         ADDQ.W    #1,rA
  616. @4        ANDI.B    #0xFF-(CAR|OVF|NEG|ZER),rFLAGS
  617.         CMPI.W    #99,rA
  618.         BLE        @5
  619.         OR.B    #(CAR|OVF),rFLAGS
  620.         SUBI.W    #100,rA
  621. @5        FlagsNZ(rA)
  622.         DEC2BCD(rA,rA)
  623. @6        PC(#1)
  624.         }
  625.     }
  626.  
  627. void i6af() /*{
  628.     if (flags&CAR) {
  629.         if ((a&1)==0) flags &=~CAR;
  630.         a=(a>>1)|128; }
  631.     else {
  632.         if(a&1) flags|=CAR;
  633.         a=a>>1; }
  634.     FlagsNZ(a);
  635. }*/
  636.     {
  637.     asm    {
  638.         BTST    #bCAR,rFLAGS
  639.         BEQ        @3
  640.         BTST    #0,rA
  641.         BNE        @4
  642.         BCLR    #bCAR,rFLAGS
  643. @4        LSR.B    #1,rA
  644.         OR.B    #0x80,rA
  645.         BRA        @5
  646. @3        BTST    #0,rA
  647.         BEQ        @6
  648.         BSET    #bCAR,rFLAGS
  649. @6        LSR.B    #1,rA
  650. @5        FlagsNZ(rA)
  651.         }
  652.     }
  653.  
  654. void i6cf() /*{ register word ta; ta=WordAt(pc); pc=WordAt(ta); }*/
  655.     {
  656.     asm    {
  657.         WordAt(rPC,D1)
  658.         WordAt(D1,rPC)
  659.         }
  660.     }
  661.  
  662. void i6df() /*{ ADC(AbsoluteAddr); pc+=2; }*/
  663.     {
  664.     asm    {
  665.         ADC(AbsoluteAddr)
  666.         PC(#2)
  667.         }
  668.     }
  669.  
  670. void i6ef() /*{ ROR(AbsoluteAddr); pc+=2; }*/
  671.     {
  672.     asm    {
  673.         ROR(AbsoluteAddr)
  674.         PC(#2)
  675.         }
  676.     }
  677.  
  678. void i70f() /*{ BST(OVF); }*/
  679.     {
  680.     asm    {
  681.         BST(#bOVF)
  682.         }
  683.     }
  684.  
  685. void i71f() /*{ ADC(IndirectYAddr); pc++; }*/
  686.     {
  687.     asm    {
  688.         ADC(IndirectYAddr)
  689.         PC(#1)
  690.         }
  691.     }
  692.  
  693. void i75f() /*{ ADC(ZeroPageXAddr); pc++; }*/
  694.     {
  695.     asm    {
  696.         ADC(ZeroPageXAddr)
  697.         PC(#1)
  698.         }
  699.     }
  700.  
  701. void i76f() /*{ ROR(ZeroPageXAddr); pc++; }*/
  702.     {
  703.     asm    {
  704.         ROR(ZeroPageXAddr)
  705.         PC(#1)
  706.         }
  707.     }
  708.  
  709. void i78f() /*{ SET(INT); }*/
  710.     {
  711.     asm    {
  712.         SET(#bINT)
  713.         }
  714.     }
  715.  
  716. void i79f() /*{ ADC(AbsoluteYAddr); pc+=2; }*/
  717.     {
  718.     asm    {
  719.         ADC(AbsoluteYAddr)
  720.         PC(#2)
  721.         }
  722.     }
  723.  
  724. void i7df() /*{ ADC(AbsoluteXAddr); pc+=2; }*/
  725.     {
  726.     asm    {
  727.         ADC(AbsoluteXAddr)
  728.         PC(#2)
  729.         }
  730.     }
  731.  
  732. void i7ef() /*{ ROR(AbsoluteXAddr); pc+=2; }*/
  733.     {
  734.     asm    {
  735.         ROR(AbsoluteXAddr)
  736.         PC(#2)
  737.         }
  738.     }
  739.  
  740. void i81f() /*{ STA(IndirectXAddr); pc++; }*/
  741.     {
  742.     asm    {
  743.         STA(IndirectXAddr)
  744.         PC(#1)
  745.         }
  746.     }
  747.  
  748. void i84f() /*{ STY(ZeroPageAddr); pc++; }*/
  749.     {
  750.     asm    {
  751.         STY(ZeroPageAddr)
  752.         PC(#1)
  753.         }
  754.     }
  755.  
  756. void i85f() /*{ STA(ZeroPageAddr); pc++; }*/
  757.     {
  758.     asm    {
  759.         STA(ZeroPageAddr)
  760.         PC(#1)
  761.         }
  762.     }
  763.  
  764. void i86f() /*{ STX(ZeroPageAddr); pc++; }*/
  765.     {
  766.     asm    {
  767.         STX(ZeroPageAddr)
  768.         PC(#1)
  769.         }
  770.     }
  771.  
  772. void i88f() /*{ y--; FlagsNZ(y); }*/
  773.     {
  774.     asm    {
  775.         SUBQ.B    #1,rY
  776.         FlagsNZ(rY)
  777.         }
  778.     }
  779.  
  780. void i8af() /*{ a=x; FlagsNZ(a); }*/
  781.     {
  782.     asm    {
  783.         MOVE.B    rX,rA
  784.         FlagsNZ(rA)
  785.         }
  786.     }
  787.  
  788. void i8cf() /*{ STY(AbsoluteAddr); pc+=2; }*/
  789.     {
  790.     asm    {
  791.         STY(AbsoluteAddr)
  792.         PC(#2)
  793.         }
  794.     }
  795.  
  796. void i8df() /*{ STA(AbsoluteAddr); pc+=2; }*/
  797.     {
  798.     asm    {
  799.         STA(AbsoluteAddr)
  800.         PC(#2)
  801.         }
  802.     }
  803.  
  804. void i8ef() /*{ STX(AbsoluteAddr); pc+=2; }*/
  805.     {
  806.     asm    {
  807.         STX(AbsoluteAddr)
  808.         PC(#2)
  809.         }
  810.     }
  811.  
  812. void i90f() /*{ BCL(CAR); }*/
  813.     {
  814.     asm    {
  815.         BCL(#bCAR)
  816.         }
  817.     }
  818.  
  819. void i91f() /*{ STA(IndirectYAddr); pc++; }*/
  820.     {
  821.     asm    {
  822.         STA(IndirectYAddr)
  823.         PC(#1)
  824.         }
  825.     }
  826.  
  827. void i94f() /*{ STY(ZeroPageXAddr); pc++; }*/
  828.     {
  829.     asm    {
  830.         STY(ZeroPageXAddr)
  831.         PC(#1)
  832.         }
  833.     }
  834.  
  835. void i95f() /*{ STA(ZeroPageXAddr); pc++; }*/
  836.     {
  837.     asm    {
  838.         STA(ZeroPageXAddr)
  839.         PC(#1)
  840.         }
  841.     }
  842.  
  843. void i96f() /*{ STX(ZeroPageYAddr); pc++; }*/
  844.     {
  845.     asm    {
  846.         STX(ZeroPageYAddr)
  847.         PC(#1)
  848.         }
  849.     }
  850.  
  851. void i98f() /*{ a=y; FlagsNZ(a); }*/
  852.     {
  853.     asm    {
  854.         MOVE.B    rY,rA
  855.         FlagsNZ(rA)
  856.         }
  857.     }
  858.  
  859. void i99f() /*{ STA(AbsoluteYAddr); pc+=2; }*/
  860.     {
  861.     asm    {
  862.         STA(AbsoluteYAddr)
  863.         PC(#2)
  864.         }
  865.     }
  866.  
  867. void i9af() /*{ sp=x; }*/
  868.     {
  869.     asm    {
  870.         MOVE.B    rX,rSP
  871.         }
  872.     }
  873.  
  874. void i9df() /*{ STA(AbsoluteXAddr); pc+=2; }*/
  875.     {
  876.     asm    {
  877.         STA(AbsoluteXAddr)
  878.         PC(#2)
  879.         }
  880.     }
  881.  
  882. void ia0f() /*{ y=ImmediateByte(); FlagsNZ(y); pc++; }*/
  883.     {
  884.     asm    {
  885.         ImmediateByte(rY)
  886.         FlagsNZ(rY)
  887.         PC(#1)
  888.         }
  889.     }
  890.  
  891. void ia1f() /*{ LDA(IndirectXAddr); pc++; }*/
  892.     {
  893.     asm    {
  894.         LDA(IndirectXAddr)
  895.         PC(#1)
  896.         }
  897.     }
  898.  
  899. void ia2f() /*{ x=ImmediateByte(); FlagsNZ(x); pc++; }*/
  900.     {
  901.     asm    {
  902.         ImmediateByte(rX)
  903.         FlagsNZ(rX)
  904.         PC(#1)
  905.         }
  906.     }
  907.  
  908. void ia4f() /*{ LDY(ZeroPageAddr); pc++; }*/
  909.     {
  910.     asm    {
  911.         LDY(ZeroPageAddr)
  912.         PC(#1)
  913.         }
  914.     }
  915.  
  916. void ia5f() /*{ LDA(ZeroPageAddr); pc++; }*/
  917.     {
  918.     asm    {
  919.         LDA(ZeroPageAddr)
  920.         PC(#1)
  921.         }
  922.     }
  923.  
  924. void ia6f() /*{ LDX(ZeroPageAddr); pc++; }*/
  925.     {
  926.     asm    {
  927.         LDX(ZeroPageAddr)
  928.         PC(#1)
  929.         }
  930.     }
  931.  
  932. void ia8f() /*{ y=a; FlagsNZ(y); }*/
  933.     {
  934.     asm    {
  935.         MOVE.B    rA,rY
  936.         FlagsNZ(rY)
  937.         }
  938.     }
  939.  
  940. void ia9f()
  941.     {
  942.     asm    {
  943.         ImmediateByte(rA)
  944.         FlagsNZ(rA)
  945.         PC(#1)
  946.         }
  947.     }
  948.  
  949. void iaaf() /*{ x=a; FlagsNZ(x); }*/
  950.     {
  951.     asm    {
  952.         MOVE.B    rA,rX
  953.         FlagsNZ(rX)
  954.         }
  955.     }
  956.  
  957. void iacf() /*{ LDY(AbsoluteAddr); pc+=2; }*/
  958.     {
  959.     asm    {
  960.         LDY(AbsoluteAddr)
  961.         PC(#2)
  962.         }
  963.     }
  964.  
  965. void iadf() /*{ LDA(AbsoluteAddr); pc+=2; }*/
  966.     {
  967.     asm    {
  968.         LDA(AbsoluteAddr)
  969.         PC(#2)
  970.         }
  971.     }
  972.  
  973. void iaef() /*{ LDX(AbsoluteAddr); pc+=2; }*/
  974.     {
  975.     asm    {
  976.         LDX(AbsoluteAddr)
  977.         PC(#2)
  978.         }
  979.     }
  980.  
  981. void ib0f() /*{ BST(CAR); }*/
  982.     {
  983.     asm    {
  984.         BST(#bCAR)
  985.         }
  986.     }
  987.  
  988. void ib1f() /*{ LDA(IndirectYAddr); pc++; }*/
  989.     {
  990.     asm    {
  991.         LDA(IndirectYAddr)
  992.         PC(#1)
  993.         }
  994.     }
  995.  
  996. void ib4f() /*{ LDY(ZeroPageXAddr); pc++; }*/
  997.     {
  998.     asm    {
  999.         LDY(ZeroPageXAddr)
  1000.         PC(#1)
  1001.         }
  1002.     }
  1003.  
  1004. void ib5f() /*{ LDA(ZeroPageXAddr); pc++; }*/
  1005.     {
  1006.     asm    {
  1007.         LDA(ZeroPageXAddr)
  1008.         PC(#1)
  1009.         }
  1010.     }
  1011.  
  1012. void ib6f() /*{ LDX(ZeroPageYAddr); pc++; }*/
  1013.     {
  1014.     asm    {
  1015.         LDX(ZeroPageYAddr)
  1016.         PC(#1)
  1017.         }
  1018.     }
  1019.  
  1020. void ib8f() /*{ CLR(OVF); }*/
  1021.     {
  1022.     asm    {
  1023.         CLR(#bOVF)
  1024.         }
  1025.     }
  1026.  
  1027. void ib9f() /*{ LDA(AbsoluteYAddr); pc+=2; }*/
  1028.     {
  1029.     asm    {
  1030.         LDA(AbsoluteYAddr)
  1031.         PC(#2)
  1032.         }
  1033.     }
  1034.  
  1035. void ibaf() /*{ x=sp; }*/
  1036.     {
  1037.     asm    {
  1038.         MOVE.B    rSP,rX
  1039.         }
  1040.     }
  1041.  
  1042. void ibcf() /*{ LDY(AbsoluteXAddr); pc+=2; }*/
  1043.     {
  1044.     asm    {
  1045.         LDY(AbsoluteXAddr)
  1046.         PC(#2)
  1047.         }
  1048.     }
  1049.  
  1050. void ibdf() /*{ LDA(AbsoluteXAddr); pc+=2; }*/
  1051.     {
  1052.     asm    {
  1053.         LDA(AbsoluteXAddr)
  1054.         PC(#2)
  1055.         }
  1056.     }
  1057.  
  1058. void ibef() /*{ LDX(AbsoluteYAddr); pc+=2; }*/
  1059.     {
  1060.     asm    {
  1061.         LDX(AbsoluteYAddr)
  1062.         PC(#2)
  1063.         }
  1064.     }
  1065.  
  1066. void ic0f() /*{
  1067.     register byte tbyte;
  1068.     tbyte=ImmediateByte();
  1069.     flags &=~(CAR+ZER+NEG);
  1070.     if (y==tbyte) flags |=CAR+ZER;
  1071.     else if (y>tbyte) flags |=CAR;
  1072.     else flags |=NEG;
  1073.     pc++;
  1074. }*/
  1075.     {
  1076.     asm    {
  1077.         CPI(rY)
  1078.         PC(#1)
  1079.         }
  1080.     }
  1081.  
  1082. void ic1f() /*{ CMP(IndirectXAddr); pc++; }*/
  1083.     {
  1084.     asm    {
  1085.         CMP(IndirectXAddr)
  1086.         PC(#1)
  1087.         }
  1088.     }
  1089.  
  1090. void ic4f() /*{ CPY(ZeroPageAddr); pc++; }*/
  1091.     {
  1092.     asm    {
  1093.         CPY(ZeroPageAddr)
  1094.         PC(#1)
  1095.         }
  1096.     }
  1097.  
  1098. void ic5f() /*{ CMP(ZeroPageAddr); pc++; }*/
  1099.     {
  1100.     asm    {
  1101.         CMP(ZeroPageAddr)
  1102.         PC(#1)
  1103.         }
  1104.     }
  1105.  
  1106. void ic6f() /*{ DECR(ZeroPageAddr); pc++; }*/
  1107.     {
  1108.     asm    {
  1109.         DECR(ZeroPageAddr)
  1110.         PC(#1)
  1111.         }
  1112.     }
  1113.  
  1114. void ic8f() /*{ y++; FlagsNZ(y); }*/
  1115.     {
  1116.     asm    {
  1117.         ADDQ.B    #1,rY
  1118.         FlagsNZ(rY)
  1119.         }
  1120.     }
  1121.  
  1122. void ic9f() /*{
  1123.     register byte tbyte;
  1124.     tbyte=ImmediateByte();
  1125.     flags &=~(CAR+ZER+NEG);
  1126.     if (a==tbyte) flags |=CAR+ZER;
  1127.     else if (a>tbyte) flags |=CAR;
  1128.         else flags |=NEG;
  1129.     pc++;
  1130. }*/
  1131.     {
  1132.     asm    {
  1133.         CPI(rA)
  1134.         PC(#1)
  1135.         }
  1136.     }
  1137.  
  1138. void icaf() /*{ x--; FlagsNZ(x); }*/
  1139.     {
  1140.     asm    {
  1141.         SUBQ.B    #1,rX
  1142.         FlagsNZ(rX)
  1143.         }
  1144.     }
  1145.  
  1146. void iccf() /*{ CPY(AbsoluteAddr); pc+=2; }*/
  1147.     {
  1148.     asm    {
  1149.         CPY(AbsoluteAddr)
  1150.         PC(#2)
  1151.         }
  1152.     }
  1153.  
  1154. void icdf() /*{ CMP(AbsoluteAddr); pc+=2; }*/
  1155.     {
  1156.     asm    {
  1157.         CMP(AbsoluteAddr)
  1158.         PC(#2)
  1159.         }
  1160.     }
  1161.  
  1162. void icef() /*{ DECR(AbsoluteAddr); pc+=2; }*/
  1163.     {
  1164.     asm    {
  1165.         DECR(AbsoluteAddr)
  1166.         PC(#2)
  1167.         }
  1168.     }
  1169.  
  1170. void id0f() /*{ BCL(ZER); }*/
  1171.     {
  1172.     asm    {
  1173.         BCL(#bZER)
  1174.         }
  1175.     }
  1176.  
  1177. void id1f() /*{ CMP(IndirectYAddr); pc++; }*/
  1178.     {
  1179.     asm    {
  1180.         CMP(IndirectYAddr)
  1181.         PC(#1)
  1182.         }
  1183.     }
  1184.  
  1185. void id5f() /*{ CMP(ZeroPageXAddr); pc++; }*/
  1186.     {
  1187.     asm    {
  1188.         CMP(ZeroPageXAddr)
  1189.         PC(#1)
  1190.         }
  1191.     }
  1192.  
  1193. void id6f() /*{ DECR(ZeroPageXAddr); pc++; }*/
  1194.     {
  1195.     asm    {
  1196.         DECR(ZeroPageXAddr)
  1197.         PC(#1)
  1198.         }
  1199.     }
  1200.  
  1201. void id8f() /*{ CLR(DEC); }*/
  1202.     {
  1203.     asm    {
  1204.         CLR(#bDEC)
  1205.         }
  1206.     }
  1207.  
  1208. void id9f() /*{ CMP(AbsoluteYAddr); pc+=2; }*/
  1209.     {
  1210.     asm    {
  1211.         CMP(AbsoluteYAddr)
  1212.         PC(#2)
  1213.         }
  1214.     }
  1215.  
  1216. void iddf() /*{ CMP(AbsoluteXAddr); pc+=2; }*/
  1217.     {
  1218.     asm    {
  1219.         CMP(AbsoluteXAddr)
  1220.         PC(#2)
  1221.         }
  1222.     }
  1223.  
  1224. void idef() /*{ DECR(AbsoluteXAddr); pc+=2; }*/
  1225.     {
  1226.     asm    {
  1227.         DECR(AbsoluteXAddr)
  1228.         PC(#2)
  1229.         }
  1230.     }
  1231.  
  1232. void ie0f() /*{
  1233.     register byte tbyte;
  1234.     tbyte=ImmediateByte();
  1235.     flags &=~(CAR+ZER+NEG);
  1236.     if (x==tbyte) flags |=CAR+ZER;
  1237.     else if (x>tbyte) flags |=CAR;
  1238.     else flags |=NEG;
  1239.     pc++;
  1240. }*/
  1241.     {
  1242.     asm    {
  1243.         CPI(rX)
  1244.         PC(#1)
  1245.         }
  1246.     }
  1247.  
  1248. void ie1f() /*{ SBC(IndirectXAddr); pc++; }*/
  1249.     {
  1250.     asm    {
  1251.         SBC(IndirectXAddr)
  1252.         PC(#1)
  1253.         }
  1254.     }
  1255.  
  1256. void ie4f() /*{ CPX(ZeroPageAddr); pc++; }*/
  1257.     {
  1258.     asm    {
  1259.         CPX(ZeroPageAddr)
  1260.         PC(#1)
  1261.         }
  1262.     }
  1263.  
  1264. void ie5f() /*{ SBC(ZeroPageAddr); pc++; }*/
  1265.     {
  1266.     asm    {
  1267.         SBC(ZeroPageAddr)
  1268.         PC(#1)
  1269.         }
  1270.     }
  1271.  
  1272. void ie6f() /*{ INCR(ZeroPageAddr); pc++; }*/
  1273.     {
  1274.     asm    {
  1275.         INCR(ZeroPageAddr)
  1276.         PC(#1)
  1277.         }
  1278.     }
  1279.  
  1280. void ie8f() /*{ x++; FlagsNZ(x); }*/
  1281.     {
  1282.     asm    {
  1283.         ADDQ.B    #1,rX
  1284.         FlagsNZ(rX)
  1285.         }
  1286.     }
  1287.  
  1288. void ie9f() /*{
  1289.     register int data;
  1290.     data=ImmediateByte();
  1291.     if (flags&DEC) {
  1292.         data = BCD2DEC(a)-BCD2DEC(data)-((flags&CAR)?0:1);
  1293.         flags &= ~(CAR+ZER+NEG+OVF);
  1294.         if (data==0) flags |=ZER+CAR;
  1295.         else if (data>0) flags |=CAR;
  1296.             else {
  1297.                 flags|=NEG;
  1298.                 data +=100; }
  1299.         DEC2BCD(data,a); }
  1300.     else {
  1301.         data = a-data-((flags&CAR)?0:1);
  1302.         flags &=~(CAR+ZER+OVF+NEG);
  1303.         if (data==0) flags |= ZER+CAR;
  1304.         else if (data>0) flags |= CAR;
  1305.             else flags|=OVF;
  1306.         data &= 255;
  1307.         flags |= data&128;
  1308.         a=data; }
  1309.     pc++; 
  1310. }*/
  1311.     {
  1312.     asm    {
  1313.         ImmediateByte(D1)
  1314.         BTST    #bDEC,rFLAGS            
  1315.         BNE        @3                        
  1316.         ANDI.W    #0x00FF,rA                
  1317.         SUB.W    D1,rA                    
  1318.         BTST    #bCAR,rFLAGS            
  1319.         BNE        @7                        
  1320.         SUB.W    #1,rA                    
  1321. @7        ANDI.B    #0xFF-(CAR|OVF|NEG|ZER),rFLAGS    
  1322.         TST.W    rA                        
  1323.         BNE        @8                        
  1324.         OR.B    #(ZER|CAR),rFLAGS        
  1325.         BRA        @9                        
  1326. @8        BMI        @10                        
  1327.         BSET    #bCAR,rFLAGS            
  1328.         BRA        @9                        
  1329. @10        BSET    #bOVF,rFLAGS            
  1330. @9        NegSet(rA)                        
  1331.         BRA        @6                        
  1332. @3        BCD2DEC(D1)                        
  1333.         BCD2DEC(rA)                        
  1334.         SUB.W    D1,rA                    
  1335.         BTST    #bCAR,rFLAGS            
  1336.         BNE        @4                        
  1337.         SUB.W    #1,rA                    
  1338. @4        ANDI.B    #0xFF-(CAR|OVF|NEG|ZER),rFLAGS    
  1339.         TST.W    rA                        
  1340.         BNE        @5                        
  1341.         OR.B    #(ZER|CAR),rFLAGS        
  1342.         BRA        @11                        
  1343. @5        BMI        @12                        
  1344.         BSET    #bCAR,rFLAGS            
  1345.         BRA        @11                        
  1346. @12        BSET    #bNEG,rFLAGS            
  1347.         ADDI.W    #100,rA                    
  1348. @11        DEC2BCD(rA,rA)                    
  1349. @6        PC(#1)
  1350.         }
  1351.     }
  1352.  
  1353. void ieaf() {}
  1354.  
  1355. void iecf() /*{ CPX(AbsoluteAddr); pc+=2; }*/
  1356.     {
  1357.     asm    {
  1358.         CPX(AbsoluteAddr)
  1359.         PC(#2)
  1360.         }
  1361.     }
  1362.  
  1363. void iedf() /*{ SBC(AbsoluteAddr); pc+=2; }*/
  1364.     {
  1365.     asm    {
  1366.         SBC(AbsoluteAddr)
  1367.         PC(#2)
  1368.         }
  1369.     }
  1370.  
  1371. void ieef() /*{ INCR(AbsoluteAddr); pc+=2; }*/
  1372.     {
  1373.     asm    {
  1374.         INCR(AbsoluteAddr)
  1375.         PC(#2)
  1376.         }
  1377.     }
  1378.  
  1379. void if0f() /*{ BST(ZER); }*/
  1380.     {
  1381.     asm    {
  1382.         BST(#bZER)
  1383.         }
  1384.     }
  1385.  
  1386. void if1f() /*{ SBC(IndirectYAddr); pc++; }*/
  1387.     {
  1388.     asm    {
  1389.         SBC(IndirectYAddr)
  1390.         PC(#1)
  1391.         }
  1392.     }
  1393.  
  1394. void if5f() /*{ SBC(ZeroPageXAddr); pc++; }*/
  1395.     {
  1396.     asm    {
  1397.         SBC(ZeroPageXAddr)
  1398.         PC(#1)
  1399.         }
  1400.     }
  1401.  
  1402. void if6f() /*{ INCR(ZeroPageXAddr); pc++; }*/
  1403.     {
  1404.     asm    {
  1405.         INCR(ZeroPageXAddr)
  1406.         PC(#1)
  1407.         }
  1408.     }
  1409.  
  1410. void if8f() /*{ SET(DEC); }*/
  1411.     {
  1412.     asm    {
  1413.         SET(#bDEC)
  1414.         }
  1415.     }
  1416.  
  1417. void if9f() /*{ SBC(AbsoluteYAddr); pc+=2; }*/
  1418.     {
  1419.     asm    {
  1420.         SBC(AbsoluteYAddr)
  1421.         PC(#2)
  1422.         }
  1423.     }
  1424.  
  1425. void ifdf() /*{ SBC(AbsoluteXAddr); pc+=2; }*/
  1426.     {
  1427.     asm    {
  1428.         SBC(AbsoluteXAddr)
  1429.         PC(#2)
  1430.         }
  1431.     }
  1432.  
  1433. void ifef() /*{ INCR(AbsoluteXAddr); pc+=2; }*/
  1434.     {
  1435.     asm    {
  1436.         INCR(AbsoluteXAddr)
  1437.         PC(#2)
  1438.         }
  1439.     }
  1440.  
  1441. void ifff()
  1442.     {
  1443.     word            tpc, tsp;
  1444.     extern    byte    *RAM, **memory;
  1445.  
  1446.     asm    {
  1447.         MOVE.W    rPC,tpc
  1448.         MOVE.W    rSP,tsp
  1449.         MOVE.B    rA,a
  1450.         MOVE.B    rX,x
  1451.         MOVE.B    rY,y
  1452.         MOVE.B    rFLAGS,flags
  1453.         }
  1454.  
  1455.     pc    = tpc;
  1456.     sp    = tsp;
  1457.     
  1458.     TrapExecute();
  1459.     
  1460.     tpc    = pc;
  1461.     tsp    = sp;
  1462.  
  1463.     asm    {
  1464.         MOVE.W    tpc,rPC
  1465.         MOVE.W    tsp,rSP
  1466.         MOVE.B    a,rA
  1467.         MOVE.B    x,rX
  1468.         MOVE.B    y,rY
  1469.         MOVE.B    flags,rFLAGS
  1470.         MOVEA.L    RAM,rRAM
  1471.         MOVE.L    rRAM,rSTACK
  1472.         ADDA.L    #256,rSTACK
  1473.         MOVEA.L    memory,rMEMORY
  1474.         }
  1475.     }
  1476.  
  1477. void inif()
  1478.     {
  1479.     #ifdef MACSBUG
  1480.     DebugStr("\pNonImplemented!");
  1481.     #endif
  1482.     
  1483.     asm    {
  1484.         PC(#2)
  1485.         }
  1486.     }
  1487.  
  1488. void InstructionInitializef()
  1489. { }
  1490.  
  1491.  
  1492. void (* instructf[256]) () = {
  1493.     i00f, i01f, inif, inif, inif, i05f, i06f, inif,
  1494.     i08f, i09f, i0af, inif, inif, i0df, i0ef, inif,
  1495.     i10f, i11f, inif, inif, inif, i15f, i16f, inif,
  1496.     i18f, i19f, inif, inif, inif, i1df, i1ef, inif,
  1497.     i20f, i21f, inif, inif, i24f, i25f, i26f, inif,
  1498.     i28f, i29f, i2af, inif, i2cf, i2df, i2ef, inif,
  1499.     i30f, i31f, inif, inif, inif, i35f, i36f, inif,
  1500.     i38f, i39f, inif, inif, inif, i3df, i3ef, inif,
  1501.     i40f, i41f, inif, inif, inif, i45f, i46f, inif,
  1502.     i48f, i49f, i4af, inif, i4cf, i4df, i4ef, inif,
  1503.     i50f, i51f, inif, inif, inif, i55f, i56f, inif,
  1504.     i58f, i59f, inif, inif, inif, i5df, i5ef, inif,
  1505.     i60f, i61f, inif, inif, inif, i65f, i66f, inif,
  1506.     i68f, i69f, i6af, inif, i6cf, i6df, i6ef, inif,
  1507.     i70f, i71f, inif, inif, inif, i75f, i76f, inif,
  1508.     i78f, i79f, inif, inif, inif, i7df, i7ef, inif,
  1509.     inif, i81f, inif, inif, i84f, i85f, i86f, inif,
  1510.     i88f, inif, i8af, inif, i8cf, i8df, i8ef, inif,
  1511.     i90f, i91f, inif, inif, i94f, i95f, i96f, inif,
  1512.     i98f, i99f, i9af, inif, inif, i9df, inif, inif,
  1513.     ia0f, ia1f, ia2f, inif, ia4f, ia5f, ia6f, inif,
  1514.     ia8f, ia9f, iaaf, inif, iacf, iadf, iaef, inif,
  1515.     ib0f, ib1f, inif, inif, ib4f, ib5f, ib6f, inif,
  1516.     ib8f, ib9f, ibaf, inif, ibcf, ibdf, ibef, inif,
  1517.     ic0f, ic1f, inif, inif, ic4f, ic5f, ic6f, inif,
  1518.     ic8f, ic9f, icaf, inif, iccf, icdf, icef, inif,
  1519.     id0f, id1f, inif, inif, inif, id5f, id6f, inif,
  1520.     id8f, id9f, inif, inif, inif, iddf, idef, inif,
  1521.     ie0f, ie1f, inif, inif, ie4f, ie5f, ie6f, inif,
  1522.     ie8f, ie9f, ieaf, inif, iecf, iedf, ieef, inif,
  1523.     if0f, if1f, inif, inif, inif, if5f, if6f, inif,
  1524.     if8f, if9f, inif, inif, inif, ifdf, ifef, ifff};
  1525.  
  1526. byte cycletimef[256]={
  1527. /*00*/    7, 6, 0, 0, 0, 3, 5, 0, 3, 2, 2, 0, 0, 4, 6, 0,
  1528. /*10*/    3, 5, 0, 0, 0, 4, 6, 0, 2, 5, 0, 0, 0, 5, 7, 0,
  1529. /*20*/    6, 6, 0, 0, 3, 3, 5, 0, 4, 2, 2, 0, 4, 4, 6, 0,
  1530. /*30*/    3, 5, 0, 0, 0, 4, 6, 0, 2, 4, 0, 0, 0, 4, 7, 0,
  1531. /*40*/    6, 6, 0, 0, 0, 3, 5, 0, 3, 2, 2, 0, 3, 4, 6, 0,
  1532. /*50*/    3, 6, 0, 0, 0, 3, 6, 0, 2, 5, 0, 0, 0, 5, 7, 0,
  1533. /*60*/    6, 6, 0, 0, 0, 3, 5, 0, 4, 2, 2, 0, 5, 4, 6, 0,
  1534. /*70*/    3, 6, 0, 0, 0, 4, 6, 0, 2, 5, 0, 0, 0, 5, 7, 0,
  1535. /*80*/    0, 6, 0, 0, 6, 3, 3, 0, 2, 0, 2, 0, 4, 4, 4, 0,
  1536. /*90*/    2, 6, 0, 0, 4, 4, 4, 0, 2, 5, 2, 0, 0, 5, 0, 0,
  1537. /*A0*/    2, 6, 2, 0, 3, 3, 3, 0, 2, 2, 2, 0, 4, 4, 4, 0,
  1538. /*B0*/    3, 6, 0, 0, 4, 4, 4, 0, 2, 5, 2, 0, 5, 5, 5, 0,
  1539. /*C0*/    2, 6, 0, 0, 3, 3, 5, 0, 2, 2, 2, 0, 4, 4, 6, 0,
  1540. /*D0*/    3, 6, 0, 0, 0, 4, 6, 0, 2, 5, 0, 0, 0, 5, 7, 0,
  1541. /*E0*/    2, 6, 0, 0, 3, 3, 5, 0, 2, 2, 2, 0, 4, 4, 6, 0,
  1542. /*F0*/    3, 6, 0, 0, 0, 4, 6, 0, 2, 5, 0, 0, 0, 5, 7, 1 };
  1543.  
  1544.  
  1545. #endif
  1546.